﻿using System;
using System.Data;
using System.Data.OleDb;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Collections.Generic;

/// <summary>
/// Descripción breve de Lotery
/// </summary>
public class Lotery
{
    public Lotery()
    {        
    }

    private const int GAMES_PER_MACHINE = 4; //Numero de juegos simultaneos en una máquina (4 jugadores).
    
    public static int[] DisorderIntArray(int[] p_x) {
        
        Random r = new Random((int)DateTime.Now.Millisecond);
        int i = p_x.Length;
        int[] temp = new int[i];

        while (i>0) {  
            int k = r.Next(0, i);    
            i--;                
            int aux = p_x[i];
            p_x[i] = p_x[k];
            p_x[k] = aux;   
        }
        return p_x;
    
    }
    public static byte[] DisorderByteArray(byte[] p_x)
    {

        Random r = new Random((int)DateTime.Now.Millisecond);
        int i = p_x.Length;
        byte[] temp = new byte[i];

        while (i > 0)
        {
            int k = r.Next(0, i);
            i--;
            byte aux = p_x[i];
            p_x[i] = p_x[k];
            p_x[k] = aux;
        }
        return p_x;

    }
    public static object[] DisorderObjectArray(object[] p_x)
    {

        Random r = new Random((int)DateTime.Now.Millisecond);
        int i = p_x.Length;
        object[] temp = new object[i];

        while (i > 0)
        {
            int k = r.Next(0, i);
            i--;
            object aux = p_x[i];
            p_x[i] = p_x[k];
            p_x[k] = aux;
        }
        return p_x;

    }
    public static List<object> DisorderObjectList(object[] p_x)
    {

        Random r = new Random((int)DateTime.Now.Millisecond);
        int i = p_x.Length;
        object[] temp = new object[i];

        while (i > 0)
        {
            int k = r.Next(0, i);
            i--;
            object aux = p_x[i];
            p_x[i] = p_x[k];
            p_x[k] = aux;
        }
        List<object> oList = new List<object>();
        oList.AddRange(p_x);
        return oList;

    }
    public static List<Machine> ObjectToMachines(List<object> oItem) {
        List<Machine> ReturnList = new List<Machine>();
        foreach (object Item in oItem) {
            ReturnList.Add((Machine)Item); 
        }
        return ReturnList; 
    }
    public static List<Player> ObjectToPlayers(List<object> oItem)
    {
        List<Player> ReturnList = new List<Player>();
        foreach (object Item in oItem)
        {
            ReturnList.Add((Player)Item);
        }
        return ReturnList;
    }
    public static int getMaxRoundsAllowedWithThisConfiguration(int p_PlayersCount, int p_MachinesCount) { 
        if(p_MachinesCount==0)return 0;
        double res = p_PlayersCount * GAMES_PER_MACHINE / p_MachinesCount;
        int result = Convert.ToInt32(Math.Round(res,0));
        if(result<0)return 0;
        return result;
    }
        
    private static Boolean canPlay(int [,] jugador,int jugadorIndex,int maquina,int ronda){
           
            for (int i = 0; i <= ronda - 1; i++){
                if (jugador[jugadorIndex,i] == maquina)
                {
                    return false;
                }
                
            }
            return true;
        }

  

    public static void MakeQualify(List<Machine> p_Machines, List<Player> p_Players, Tournament p_Tournament, ref QualifyRounds oRounds)
    {
        try
        {
            if (p_Tournament.TournamentType == 0)
            { //Draw based 

                Random rnd;
                rnd = new Random((int)DateTime.Now.Millisecond); //Semilla para el random
                //Boolean DatosValidos = false;
                int numJugadores = p_Players.Count;
                int numMaquinas = p_Machines.Count;
                int numRondas = p_Tournament.QualifyRounds;


                //Inicializamos matriz
                int[,] vJugadores = new int[numJugadores, numRondas];
                for (int x = 0; x < numJugadores; x++)
                {
                    for (int y = 0; y < numRondas; y++)
                    {
                        vJugadores[x, y] = -1;
                    }
                }
                //TODO inicializamos a -1; las rondas
                List<int> vMaquinas = new List<int>();

                for (int ronda = 0; ronda < numRondas; ronda++)
                {
                    //Genero vector con jugadores pendientes de asignar máquina en esta ronda
                    List<int> vPendientes = new List<int>(numJugadores);// int[numJugadores];

                    for (int i = 0; i < numJugadores; i++)
                    {
                        vPendientes.Add(i);
                    }

                    while (vPendientes.Count != 0)
                    {

                        if (vMaquinas.Count == 0)
                        {
                            for (int i = 0; i < numMaquinas; i++)
                            {
                                vMaquinas.Add(i);
                            }
                        }


                        //cout << "Tamaño del vector de pendientes: " << vPendientes.size() << endl;
                        int desplazamientoJ = rnd.Next(0, vPendientes.Count);
                        //NOTA FER, la funcion randomNumber de Carlos retorna valores random de 0-X
                        // randomNumber(vPendientes.size() -1);
                        //Next lo hace de (X a X-1) por lo tanto el -1 no lo pongo (posible errata)
                        int jugador = vPendientes[desplazamientoJ];
                        //int desplazamientoM = randomNumber(vMaquinas.size() - 1);

                        //NUEVO
                        //int desplazamientoM = rnd.Next(0, vMaquinas.Count);
                        //int maquina = vMaquinas[desplazamientoM];
                        //int maquina = vMaquinas.front();
                        int maquina = vMaquinas[0];
                        //NUEVO

                        //cout << "Desplazamiento: " << desplazamientoJ
                        //   << " Jugador: " << jugador << endl;

                        if (canPlay(vJugadores, jugador, maquina, ronda))
                        {
                            vJugadores[jugador, ronda] = maquina;
                            //vMaquinas.RemoveAt(desplazamientoM);
                            vMaquinas.Remove(maquina);
                            vPendientes.RemoveAt(desplazamientoJ);
                        }
                        else
                        {
                            // Buscamos un posible reemplazo y hacemos un intercambio.
                            // Solo lo intentamos una vez. Si fallamos en la siguiente iteración se buscara otro reemplazo.
                            //int reemplazoJ = randomNumber(numJugadores - 1);
                            int reemplazoJ = rnd.Next(0, numJugadores);

                            // Si puede jugar a la máquina a la que el original no podía, hacemos el intercambio...
                            if (canPlay(vJugadores, reemplazoJ, maquina, ronda))
                            {
                                int reemplazoM = vJugadores[reemplazoJ, ronda];
                                vJugadores[reemplazoJ, ronda] = maquina;
                                //vMaquinas.erase(vMaquinas.begin() + desplazamientoM);
                                //vMaquinas.RemoveAt(desplazamientoM); 
                                vMaquinas.Remove(maquina);
                                // Si no tenía máquina asignada, ya la tiene.
                                // Habrá que sacarlo de la lista de pendientes...
                                if (reemplazoM == -1)
                                {

                                    //int it = vPendientes.Find(reemplazoJ); 
                                    //vector<int>::iterator it = find(vPendientes.begin(), vPendientes.end(), reemplazoJ);
                                    vPendientes.Remove(reemplazoJ);
                                }
                                // Por contra, si sí tenía máquina asignada...
                                else
                                {
                                    // Probamos a ver si le sirve al jugador conflictivo, y se la asignamos, y lo borramos de la lista de pendientes.
                                    if (canPlay(vJugadores, jugador, reemplazoM, ronda))
                                    {
                                        vJugadores[jugador, ronda] = reemplazoM;
                                        vPendientes.RemoveAt(desplazamientoJ);
                                    }
                                    // Si tampoco puede juega a esta nueva máquina, esta máquina está sin asignar y hay que añadirla a la lista de máquinas pendientes
                                    else
                                    {
                                        //vMaquinas.Add(reemplazoM);
                                        vMaquinas.Insert(0, reemplazoM);
                                    }
                                }
                            }
                        }
                    }
                }

                //Verificador
                //Asignamos las posiciones de juego
                int[,] vMarcadores = new int[numJugadores, numRondas];
                //for (int j = 0; j < numJugadores; j++)
                //{

                for (int r = 0; r < numRondas; r++)
                {
                    for (int m = 0; m < numMaquinas; m++)
                    {
                        List<int> Marcadores = new List<int>();
                        //Inicializamos las posiciones disponibles para cada maquina en cada ronda
                        //Contamos cuantos marcadores con esa maquina hay en la ronda
                        int TotalMaquinas = 0;
                        for (int j = 0; j < numJugadores; j++)
                        {
                            if (vJugadores[j, r] == m)
                            {
                                TotalMaquinas++;
                            }
                        }

                        for (int p = 0; p < TotalMaquinas; p++)
                        {
                            Marcadores.Add(p);
                        }
                        //Volvemos a recorrer asignando para cada maquina
                        Boolean SigueAsignando = true;
                        while (SigueAsignando == true)
                        {
                            for (int j = 0; j < numJugadores; j++)
                            {
                                if (vJugadores[j, r] == m)
                                {
                                    //Seleccionamos posición entre las restantes
                                    int Pos = rnd.Next(0, Marcadores.Count);
                                    vMarcadores[j, r] = Marcadores[Pos];
                                    Marcadores.RemoveAt(Pos);
                                }
                                if (Marcadores.Count == 0) SigueAsignando = false;


                            }
                            SigueAsignando = false;
                        }
                    }
                }

                //Control errores
                //Boolean PorPosicion = false;
                for (int i = 0; i < numJugadores; i++)
                {


                    for (int j = 0; j < numRondas; j++)
                    {
                        //vJugadores[i, j]
                        //vMarcadores[i, j]
                        int Player_Number = i + 1;
                        int Machine_Number = vJugadores[i, j] + 1;
                        int PlayInPosition = vMarcadores[i, j] + 1;

                        Player oPlayer = p_Players[(Player_Number - 1)]; //para diferentes torneos sin numeros consecutivos no se usa el numero sino la posicion //JUNIOR 2010

                        //REVISION
                        //Player oPlayer = p_Players.Find(delegate(Player p) { return p.Player_Number == Player_Number; });

                        //REVISION Para que no tengan que ser numeros consecutivos
                        //Machine oMachine = p_Machines.Find(delegate(Machine m) { return m.Machine_Number == Machine_Number; });
                        Machine oMachine = p_Machines[(Machine_Number - 1)];

                        //Para que no tengan que existir jugadores consecutivos
                        QualifyRound oRound = new QualifyRound(p_Tournament.Pk_Tournament,
                                                               oPlayer.Pk_Player,
                                                               oPlayer.Player_Nick,
                                                               j + 1,
                                                               oPlayer.Fk_PlayerZone,
                                                               oMachine.Pk_Machine,
                                                               oMachine.Machine_Acron,
                                                               oMachine.Machine_Number,
                                                               PlayInPosition,
                                                               -1,
                                                               oPlayer.Player_Number
                                                               );
                        //QualifyRound oRound = new QualifyRound(p_Tournament.Pk_Tournament,
                        //                                       oPlayer.Pk_Player,
                        //                                       oPlayer.Player_Nick,
                        //                                       j + 1,
                        //                                       oPlayer.Fk_PlayerZone,
                        //                                       oMachine.Pk_Machine,
                        //                                       oMachine.Machine_Acron,
                        //                                       oMachine.Machine_Number,
                        //                                       PlayInPosition,
                        //                                       -1,
                        //                                       Player_Number
                        //                                       );
                        oRounds.Rounds.Add(oRound);
                    }
                }

            }
            else { 
            //Free play based all players all machines
                foreach (Player iPlayer in p_Players) {
                    foreach (Machine iMachine in p_Machines) {
                        QualifyRound oRound = new QualifyRound(p_Tournament.Pk_Tournament,
                                                                  iPlayer.Pk_Player,
                                                                  iPlayer.Player_Nick,
                                                                  -1,
                                                                  iPlayer.Fk_PlayerZone,
                                                                  iMachine.Pk_Machine,
                                                                  iMachine.Machine_Acron,
                                                                  iMachine.Machine_Number,
                                                                  -1,
                                                                  -1,
                                                                  iPlayer.Player_Number
                                                                  );
                        oRounds.Rounds.Add(oRound);
                    }   
                    
                } 
            }

        }
        catch (Exception Ex)
        {
            //  Console.Write(Ex.ToString()); 
            throw;

        }

    }

    public static void MakePlayOffs(List<Machine> p_Machines, List<Player> p_Players, Tournament p_Tournament, ref PlayoffRounds oRounds)
    {
        try
        {
            if (p_Tournament.TournamentType == 0)
            {

                Random rnd;
                rnd = new Random((int)DateTime.Now.Millisecond); //Semilla para el random
                //Boolean DatosValidos = false;
                int numJugadores = p_Players.Count;
                int numMaquinas = p_Machines.Count;
                int numRondas = p_Tournament.PlayOffsRounds;


                //Inicializamos matriz
                int[,] vJugadores = new int[numJugadores, numRondas];
                for (int x = 0; x < numJugadores; x++)
                {
                    for (int y = 0; y < numRondas; y++)
                    {
                        vJugadores[x, y] = -1;
                    }
                }
                //TODO inicializamos a -1; las rondas
                List<int> vMaquinas = new List<int>();

                for (int ronda = 0; ronda < numRondas; ronda++)
                {
                    //Genero vector con jugadores pendientes de asignar máquina en esta ronda
                    List<int> vPendientes = new List<int>(numJugadores);// int[numJugadores];

                    for (int i = 0; i < numJugadores; i++)
                    {
                        vPendientes.Add(i);
                    }

                    while (vPendientes.Count != 0)
                    {

                        if (vMaquinas.Count == 0)
                        {
                            for (int i = 0; i < numMaquinas; i++)
                            {
                                vMaquinas.Add(i);
                            }
                        }


                        //cout << "Tamaño del vector de pendientes: " << vPendientes.size() << endl;
                        int desplazamientoJ = rnd.Next(0, vPendientes.Count);
                        //NOTA FER, la funcion randomNumber de Carlos retorna valores random de 0-X
                        // randomNumber(vPendientes.size() -1);
                        //Next lo hace de (X a X-1) por lo tanto el -1 no lo pongo (posible errata)
                        int jugador = vPendientes[desplazamientoJ];
                        //int desplazamientoM = randomNumber(vMaquinas.size() - 1);

                        //NUEVO
                        //int desplazamientoM = rnd.Next(0, vMaquinas.Count);
                        //int maquina = vMaquinas[desplazamientoM];
                        //int maquina = vMaquinas.front();
                        int maquina = vMaquinas[0];
                        //NUEVO

                        //cout << "Desplazamiento: " << desplazamientoJ
                        //   << " Jugador: " << jugador << endl;

                        if (canPlay(vJugadores, jugador, maquina, ronda))
                        {
                            vJugadores[jugador, ronda] = maquina;
                            //vMaquinas.RemoveAt(desplazamientoM);
                            vMaquinas.Remove(maquina);
                            vPendientes.RemoveAt(desplazamientoJ);
                        }
                        else
                        {
                            // Buscamos un posible reemplazo y hacemos un intercambio.
                            // Solo lo intentamos una vez. Si fallamos en la siguiente iteración se buscara otro reemplazo.
                            //int reemplazoJ = randomNumber(numJugadores - 1);
                            int reemplazoJ = rnd.Next(0, numJugadores);

                            // Si puede jugar a la máquina a la que el original no podía, hacemos el intercambio...
                            if (canPlay(vJugadores, reemplazoJ, maquina, ronda))
                            {
                                int reemplazoM = vJugadores[reemplazoJ, ronda];
                                vJugadores[reemplazoJ, ronda] = maquina;
                                //vMaquinas.erase(vMaquinas.begin() + desplazamientoM);
                                //vMaquinas.RemoveAt(desplazamientoM); 
                                vMaquinas.Remove(maquina);
                                // Si no tenía máquina asignada, ya la tiene.
                                // Habrá que sacarlo de la lista de pendientes...
                                if (reemplazoM == -1)
                                {

                                    //int it = vPendientes.Find(reemplazoJ); 
                                    //vector<int>::iterator it = find(vPendientes.begin(), vPendientes.end(), reemplazoJ);
                                    vPendientes.Remove(reemplazoJ);
                                }
                                // Por contra, si sí tenía máquina asignada...
                                else
                                {
                                    // Probamos a ver si le sirve al jugador conflictivo, y se la asignamos, y lo borramos de la lista de pendientes.
                                    if (canPlay(vJugadores, jugador, reemplazoM, ronda))
                                    {
                                        vJugadores[jugador, ronda] = reemplazoM;
                                        vPendientes.RemoveAt(desplazamientoJ);
                                    }
                                    // Si tampoco puede juega a esta nueva máquina, esta máquina está sin asignar y hay que añadirla a la lista de máquinas pendientes
                                    else
                                    {
                                        //vMaquinas.Add(reemplazoM);
                                        vMaquinas.Insert(0, reemplazoM);
                                    }
                                }
                            }
                        }
                    }
                }

                //Verificador
                //Asignamos las posiciones de juego
                int[,] vMarcadores = new int[numJugadores, numRondas];
                //for (int j = 0; j < numJugadores; j++)
                //{

                for (int r = 0; r < numRondas; r++)
                {
                    for (int m = 0; m < numMaquinas; m++)
                    {
                        List<int> Marcadores = new List<int>();
                        //Inicializamos las posiciones disponibles para cada maquina en cada ronda
                        //Contamos cuantos marcadores con esa maquina hay en la ronda
                        int TotalMaquinas = 0;
                        for (int j = 0; j < numJugadores; j++)
                        {
                            if (vJugadores[j, r] == m)
                            {
                                TotalMaquinas++;
                            }
                        }

                        for (int p = 0; p < TotalMaquinas; p++)
                        {
                            Marcadores.Add(p);
                        }
                        //Volvemos a recorrer asignando para cada maquina
                        Boolean SigueAsignando = true;
                        while (SigueAsignando == true)
                        {
                            for (int j = 0; j < numJugadores; j++)
                            {
                                if (vJugadores[j, r] == m)
                                {
                                    //Seleccionamos posición entre las restantes
                                    int Pos = rnd.Next(0, Marcadores.Count);
                                    vMarcadores[j, r] = Marcadores[Pos];
                                    Marcadores.RemoveAt(Pos);
                                }
                                if (Marcadores.Count == 0) SigueAsignando = false;


                            }
                            SigueAsignando = false;
                        }
                    }
                }


                for (int i = 0; i < numJugadores; i++)
                {

                    for (int j = 0; j < numRondas; j++)
                    {
                        //vJugadores[i, j]
                        //vMarcadores[i, j]
                        int Player_Number = i + 1;
                        int Machine_Number = vJugadores[i, j] + 1;
                        int PlayInPosition = vMarcadores[i, j] + 1;

                        //Se cambia ya que no son todos los jugadores, usamos las posiciones del array.
                        //Player oPlayer = p_Players.Find(delegate(Player p) { return p.Player_Number == Player_Number; });
                        //Machine oMachine = p_Machines.Find(delegate(Machine m) { return m.Machine_Number == Machine_Number; });
                        Player oPlayer = p_Players[Player_Number - 1];
                        Machine oMachine = p_Machines[Machine_Number - 1];


                        PlayoffRound oRound = new PlayoffRound(p_Tournament.Pk_Tournament,
                                                               oPlayer.Pk_Player,
                                                               oPlayer.Player_Nick,
                                                               j + 1,
                                                               oPlayer.Fk_PlayerZone,
                                                               oMachine.Pk_Machine,
                                                               oMachine.Machine_Acron,
                                                               oMachine.Machine_Number,
                                                               PlayInPosition,
                                                               -1,
                                                               oPlayer.Player_Number
                                                               );
                        oRounds.Rounds.Add(oRound);
                    }
                }
            }
            else { 
            //Free play
                foreach (Player iPlayer in p_Players)
                {
                    foreach (Machine iMachine in p_Machines) {
                        PlayoffRound oRound = new PlayoffRound(p_Tournament.Pk_Tournament,
                                                                  iPlayer.Pk_Player,
                                                                  iPlayer.Player_Nick,
                                                                  -1,
                                                                  iPlayer.Fk_PlayerZone,
                                                                  iMachine.Pk_Machine,
                                                                  iMachine.Machine_Acron,
                                                                  iMachine.Machine_Number,
                                                                  -1,
                                                                  -1,
                                                                  iPlayer.Player_Number
                                                                  );
                        oRounds.Rounds.Add(oRound);
                    }
                }
            }


        }
        catch (Exception Ex)
        {
            //  Console.Write(Ex.ToString()); 
            throw;

        }

    }


    public static void MakePlayOffsLeague(List<Machine> p_Machines, List<Player> p_Players, Tournament p_Tournament, ref PlayoffRounds oRounds)
    {
        try
        {
            Random rnd;
            rnd = new Random((int)DateTime.Now.Millisecond); //Semilla para el random
            int numJugadores = p_Players.Count;
            int numMaquinas = p_Machines.Count;
            int numRondas = p_Tournament.PlayOffsRounds;


            //Inicializamos matriz
            int[,] vJugadores = new int[numJugadores, numRondas];
            for (int x = 0; x < numJugadores; x++)
            {
                for (int y = 0; y < numRondas; y++)
                {
                    vJugadores[x, y] = -1;
                }
            }
            
            List<int> vMaquinas = new List<int>();

            for (int ronda = 0; ronda < numRondas; ronda++)
            {
                //Genero vector con jugadores pendientes de asignar máquina en esta ronda
                List<int> vPendientes = new List<int>(numJugadores);

                for (int i = 0; i < numJugadores; i++)
                {
                    vPendientes.Add(i);
                }

                while (vPendientes.Count != 0)
                {

                    if (vMaquinas.Count == 0)
                    {
                        for (int i = 0; i < numMaquinas; i++)
                        {
                            vMaquinas.Add(i);
                        }
                    }                    
                   
                    int desplazamientoJ = rnd.Next(0, vPendientes.Count);
                    int jugador = vPendientes[desplazamientoJ];
                    int maquina = vMaquinas[0];
                    
                    if (canPlay(vJugadores, jugador, maquina, ronda))
                    {
                        vJugadores[jugador, ronda] = maquina;
                        vMaquinas.Remove(maquina);
                        vPendientes.RemoveAt(desplazamientoJ);
                    }
                    else
                    {
                        // Buscamos un posible reemplazo y hacemos un intercambio.
                        // Solo lo intentamos una vez. Si fallamos en la siguiente iteración se buscara otro reemplazo.
                        int reemplazoJ = rnd.Next(0, numJugadores);

                        // Si puede jugar a la máquina a la que el original no podía, hacemos el intercambio...
                        if (canPlay(vJugadores, reemplazoJ, maquina, ronda))
                        {
                            int reemplazoM = vJugadores[reemplazoJ, ronda];
                            vJugadores[reemplazoJ, ronda] = maquina;
                            vMaquinas.Remove(maquina);
                            // Si no tenía máquina asignada, ya la tiene.
                            // Habrá que sacarlo de la lista de pendientes...
                            if (reemplazoM == -1)
                            {
                                vPendientes.Remove(reemplazoJ);
                            }
                            // Por contra, si sí tenía máquina asignada...
                            else
                            {
                                // Probamos a ver si le sirve al jugador conflictivo, y se la asignamos, y lo borramos de la lista de pendientes.
                                if (canPlay(vJugadores, jugador, reemplazoM, ronda))
                                {
                                    vJugadores[jugador, ronda] = reemplazoM;
                                    vPendientes.RemoveAt(desplazamientoJ);
                                }
                                // Si tampoco puede juega a esta nueva máquina, esta máquina está sin asignar y hay que añadirla a la lista de máquinas pendientes
                                else
                                {
                                    vMaquinas.Insert(0, reemplazoM);
                                }
                            }
                        }
                    }
                }
            }

            //Verificador
            //Asignamos las posiciones de juego
            int[,] vMarcadores = new int[numJugadores, numRondas];
       
            for (int r = 0; r < numRondas; r++)
            {
                for (int m = 0; m < numMaquinas; m++)
                {
                    List<int> Marcadores = new List<int>();
                    //Inicializamos las posiciones disponibles para cada maquina en cada ronda
                    //Contamos cuantos marcadores con esa maquina hay en la ronda
                    int TotalMaquinas = 0;
                    for (int j = 0; j < numJugadores; j++)
                    {
                        if (vJugadores[j, r] == m)
                        {
                            TotalMaquinas++;
                        }
                    }

                    for (int p = 0; p < TotalMaquinas; p++)
                    {
                        Marcadores.Add(p);
                    }
                    //Volvemos a recorrer asignando para cada maquina
                    Boolean SigueAsignando = true;
                    while (SigueAsignando == true)
                    {
                        for (int j = 0; j < numJugadores; j++)
                        {
                            if (vJugadores[j, r] == m)
                            {
                                //Seleccionamos posición entre las restantes
                                int Pos = rnd.Next(0, Marcadores.Count);
                                vMarcadores[j, r] = Marcadores[Pos];
                                Marcadores.RemoveAt(Pos);
                            }
                            if (Marcadores.Count == 0) SigueAsignando = false;


                        }
                        SigueAsignando = false;
                    }
                }
            }


            for (int i = 0; i < numJugadores; i++)
            {

                for (int j = 0; j < numRondas; j++)
                {
                    int Player_Number = i;
                    int Machine_Number = vJugadores[i, j];
                    int PlayInPosition = vMarcadores[i, j];

                    Player oPlayer = p_Players[Player_Number];
                    Machine oMachine = p_Machines[Machine_Number];

                    /* Constructor de PlayoffRound
                     public PlayoffRound(int p_Pk_Tournament,
                        int p_Pk_Player,   
                        string p_Player_Nick,                        
                        int p_Round_Number,
                        int p_Pk_Player_Zone,
                        int p_Pk_Machine,
                        string p_Machine_Acron,  
                        int p_Machine_Number,
                        int p_PlayInPosition,
                        Int64 p_Score,int p_Player_Number)
                     */
                    PlayoffRound oRound = new PlayoffRound(p_Tournament.Pk_Tournament,
                                                           oPlayer.Pk_Player,
                                                           oPlayer.Player_Nick,
                                                           j + 1,//las rondas empiezan en 1 no en 0
                                                           oPlayer.Fk_PlayerZone,
                                                           oMachine.Pk_Machine,
                                                           oMachine.Machine_Acron,
                                                           oMachine.Machine_Number,
                                                           PlayInPosition,
                                                           -1,//Se inicializan los puntos
                                                           oPlayer.Player_Number
                                                           );
                    oRounds.Rounds.Add(oRound);
                }
            }



        }
        catch (Exception Ex)
        {
            throw;

        }

    }

}
